home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / var / lib / python-support / python2.6 / rdflib / syntax / serializers / PrettyXMLSerializer.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  4.8 KB  |  140 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from rdflib import RDF
  5. from rdflib import URIRef, Literal, BNode
  6. from rdflib.util import first, uniq, more_than
  7. from rdflib.syntax.serializers import Serializer
  8. from rdflib.syntax.serializers.XMLWriter import XMLWriter
  9. XMLLANG = 'http://www.w3.org/XML/1998/namespacelang'
  10.  
  11. def fix(val):
  12.     '''strip off _: from nodeIDs... as they are not valid NCNames'''
  13.     if val.startswith('_:'):
  14.         return val[2:]
  15.     return val
  16.  
  17.  
  18. class PrettyXMLSerializer(Serializer):
  19.     
  20.     def __init__(self, store, max_depth = 3):
  21.         super(PrettyXMLSerializer, self).__init__(store)
  22.  
  23.     
  24.     def serialize(self, stream, base = None, encoding = None, **args):
  25.         self._PrettyXMLSerializer__serialized = { }
  26.         store = self.store
  27.         self.base = base
  28.         self.max_depth = args.get('max_depth', 3)
  29.         if not self.max_depth > 0:
  30.             raise AssertionError, 'max_depth must be greater than 0'
  31.         namespaces = { }
  32.         possible = uniq(store.predicates()) + uniq(store.objects(None, RDF.type))
  33.         for predicate in possible:
  34.             (prefix, namespace, local) = nm.compute_qname(predicate)
  35.             namespaces[prefix] = namespace
  36.         
  37.         namespaces['rdf'] = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
  38.         writer.push(RDF.RDF)
  39.         writer.namespaces(namespaces.iteritems())
  40.         for subject in store.subjects():
  41.             if (None, None, subject) in store:
  42.                 if (subject, None, subject) in store:
  43.                     self.subject(subject, 1)
  44.                 
  45.             (subject, None, subject) in store
  46.             self.subject(subject, 1)
  47.         
  48.         for subject in store.subjects():
  49.             self.subject(subject, 1)
  50.         
  51.         writer.pop(RDF.RDF)
  52.         self._PrettyXMLSerializer__serialized = None
  53.  
  54.     
  55.     def subject(self, subject, depth = 1):
  56.         store = self.store
  57.         writer = self.writer
  58.         if subject not in self._PrettyXMLSerializer__serialized:
  59.             self._PrettyXMLSerializer__serialized[subject] = 1
  60.             type = first(store.objects(subject, RDF.type))
  61.             
  62.             try:
  63.                 self.nm.qname(type)
  64.             except:
  65.                 type = None
  66.  
  67.             if not type:
  68.                 pass
  69.             element = RDF.Description
  70.             writer.push(element)
  71.             if isinstance(subject, BNode):
  72.                 
  73.                 def subj_as_obj_more_than(ceil):
  74.                     return more_than(store.triples((None, None, subject)), ceil)
  75.  
  76.                 if depth == 1 or subj_as_obj_more_than(0) or subj_as_obj_more_than(1):
  77.                     writer.attribute(RDF.nodeID, fix(subject))
  78.                 
  79.             else:
  80.                 writer.attribute(RDF.about, self.relativize(subject))
  81.             if (subject, None, None) in store:
  82.                 for predicate, object in store.predicate_objects(subject):
  83.                     if not predicate == RDF.type and object == type:
  84.                         self.predicate(predicate, object, depth + 1)
  85.                         continue
  86.                 
  87.             
  88.             writer.pop(element)
  89.         
  90.  
  91.     
  92.     def predicate(self, predicate, object, depth = 1):
  93.         writer = self.writer
  94.         store = self.store
  95.         writer.push(predicate)
  96.         if isinstance(object, Literal):
  97.             attributes = ''
  98.             if object.language:
  99.                 writer.attribute(XMLLANG, object.language)
  100.             
  101.             if object.datatype:
  102.                 writer.attribute(RDF.datatype, object.datatype)
  103.             
  104.             writer.text(object)
  105.         elif object in self._PrettyXMLSerializer__serialized or (object, None, None) not in store:
  106.             if isinstance(object, BNode):
  107.                 if more_than(store.triples((None, None, object)), 0):
  108.                     writer.attribute(RDF.nodeID, fix(object))
  109.                 
  110.             else:
  111.                 writer.attribute(RDF.resource, self.relativize(object))
  112.         else:
  113.             items = []
  114.             for item in store.items(object):
  115.                 if isinstance(item, Literal):
  116.                     items = None
  117.                     continue
  118.                 items.append(item)
  119.             
  120.             if first(store.objects(object, RDF.first)):
  121.                 collection = object
  122.                 self._PrettyXMLSerializer__serialized[object] = 1
  123.                 writer.attribute(RDF.parseType, 'Collection')
  124.                 while collection:
  125.                     item = first(store.objects(collection, RDF.first))
  126.                     if item:
  127.                         self.subject(item)
  128.                     
  129.                     collection = first(store.objects(collection, RDF.rest))
  130.                     self._PrettyXMLSerializer__serialized[collection] = 1
  131.             elif depth <= self.max_depth:
  132.                 self.subject(object, depth + 1)
  133.             elif isinstance(object, BNode):
  134.                 writer.attribute(RDF.nodeID, fix(object))
  135.             else:
  136.                 writer.attribute(RDF.resource, self.relativize(object))
  137.         writer.pop(predicate)
  138.  
  139.  
  140.